#pragma once
#include "logger.hpp"
#include <memory>
#include <iostream>
#include <fstream>
#include <mysql/mysql.h>
#include <jsoncpp/json/json.h>

namespace liang
{
    class MysqlHelper
    {
    public:
        // 初始化数据库连接
        static MYSQL *mysql_create(const std::string &host,
                                   const std::string &user,
                                   const std::string &password,
                                   const std::string &dbname,
                                   uint16_t port = 3306)
        {
            MYSQL *mysql = mysql_init(nullptr);
            if (mysql == nullptr)
            {
                ERROR("mysql_init error");
                return nullptr;
            }
            if (mysql_real_connect(mysql, host.c_str(), user.c_str(),
                                   password.c_str(), dbname.c_str(), port, nullptr, 0) == nullptr)
            {
                ERROR("mysql_connect error");
                return nullptr;
            }
            if (mysql_set_character_set(mysql, "utf8") != 0)
            {
                ERROR("mysql_set_character_set error");
                return nullptr;
            }
            return mysql;
        }

        // 执行sql语句
        static bool mysql_exec(MYSQL *mysql, const std::string &sql)
        {
            int ret = mysql_query(mysql, sql.c_str());
            if (ret != 0)
            {
                ERROR("mysql_exec error: %s [error: %s]", sql.c_str(), mysql_error(mysql));
                return false;
            }
            return true;
        }

        // 销毁数据库句柄
        static void mysql_destory(MYSQL *mysql)
        {
            if (mysql != nullptr)
                mysql_close(mysql);
        }
    };

    class JsonHelper
    {
    public:
        // json序列化
        static bool serialize(const Json::Value &root, std::string &str)
        {
            Json::StreamWriterBuilder swb;
            swb["emitUTF8"] = true;
            // 不要用std::make_unique, 直接用构造函数, 因为newStreamWriter返回的就是一个指针
            std::unique_ptr<Json::StreamWriter> sw(swb.newStreamWriter());
            std::stringstream ss;
            int ret = sw->write(root, &ss);
            if (ret != 0)
            {
                ERROR("json_serialze error");
                return false;
            }
            str = ss.str();
            return true;
        }

        // json反序列化
        static bool unserialize(const std::string &str, Json::Value &root)
        {
            Json::CharReaderBuilder crb;
            std::unique_ptr<Json::CharReader> cr(crb.newCharReader());
            std::string err;
            bool ret = cr->parse(str.c_str(), str.c_str() + str.size(), &root, &err);
            if (!ret)
            {
                ERROR("json_unserialize error");
                return false;
            }
            return true;
        }
    };

    class StrHelper
    {
    public:
        // 切分字符串
        static int split(const std::string &src, const std::string &sep, std::vector<std::string> &res)
        {
            int pos = 0;   // 目前查找的起始位置
            int index = 0; // 查找到的位置
            while (pos < src.size())
            {
                std::string substr;
                index = src.find(sep, pos);
                if (index == std::string::npos)
                {
                    substr = src.substr(pos);
                    if (!substr.empty())
                        res.push_back(substr);
                    break;
                }
                else
                {
                    substr = src.substr(pos, index - pos);
                    pos = index + sep.size();
                    if (!substr.empty())
                        res.push_back(substr);
                }
            }
            return res.size();
        }
    };

    class FileHelper
    {
    public:
        static bool read(const std::string &filename, std::string &body)
        {
            // 打开文件
            std::ifstream ifs(filename, std::ios::binary);
            if (!ifs.is_open()) 
            {
                ERROR("%s 文件打开失败", filename.c_str());
                return false;
            }
            // 获取文件大小
            size_t fsize = 0;
            ifs.seekg(0, std::ios::end);
            fsize = ifs.tellg();
            ifs.seekg(0, std::ios::beg);
            body.resize(fsize);
            // 读取文件
            ifs.read(&body[0], fsize);
            if (!ifs.good())
            {
                ERROR("%s 文件读取内容失败", filename.c_str());
                ifs.close();
                return false;
            }
            // 关闭文件
            ifs.close();
            return true;
        }
    };
}
